home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / editors / emcs1857 / 1857sr~1.zoo / src / indent.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  15.7 KB  |  608 lines
  1. /* Indentation functions.
  2.    Copyright (C) 1985, 1986, 1987, 1988, 1990, 1991
  3.             Free Software Foundation, Inc.
  4.  
  5. This file is part of GNU Emacs.
  6.  
  7. GNU Emacs is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GNU Emacs is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Emacs; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21.  
  22. /* Modified 1991 for 8-bit character support by Howard Gayle.
  23.  * See chartab.c for details. */
  24.  
  25.  
  26. #include "config.h"
  27. #include "lisp.h"
  28. #include "buffer.h"
  29. #include "chartab.h"
  30. #include "indent.h"
  31. #include "window.h"
  32. #include "termchar.h"
  33. #include "termopts.h"
  34.  
  35. /* Indentation can insert tabs if this is non-zero;
  36.    otherwise always uses spaces */
  37. int indent_tabs_mode;
  38.  
  39. #define min(a, b) ((a) < (b) ? (a) : (b))
  40. #define max(a, b) ((a) > (b) ? (a) : (b))
  41.  
  42. /* These three values memoize the current column to avoid recalculation */
  43. /* Some things in set last_known_column_point to -1
  44.   to mark the memoized value as invalid */
  45. /* Last value returned by current_column */
  46. int last_known_column;
  47. /* Value of point when current_column was called */
  48. int last_known_column_point;
  49. /* Value of MODIFF when current_column was called */
  50. int last_known_column_modified;
  51.  
  52. extern int minibuf_prompt_width;
  53.  
  54. DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
  55.   "Return the horizontal position of point.  Beginning of line is column 0.\n\
  56. This is calculated by adding together the widths of all the displayed\n\
  57. representations of the character between the start of the previous line\n\
  58. and point.  Ignores finite width of screen, which means that\n\
  59. this function may return values greater than (screen-width).\n\
  60. Whether the line is visible (if `selective-display' is t) has no effect.")
  61.   ()
  62. {
  63.   Lisp_Object temp;
  64.   XFASTINT (temp) = current_column ();
  65.   return temp;
  66. }
  67.  
  68. int
  69. current_column ()
  70. {
  71.   register int col;
  72.   register unsigned char *ptr, *stop;
  73.   register char_t c;
  74.   register int tab_seen;
  75.   register int post_tab;
  76.   register int tab_width = XINT (current_buffer->tab_width);
  77.   register struct Lisp_Chartab *cp;
  78.  
  79.   if (point == last_known_column_point
  80.       && MODIFF == last_known_column_modified)
  81.     return last_known_column;
  82.  
  83.   /* Make a pointer for decrementing through the chars before point.  */
  84.   ptr = &FETCH_CHAR (point - 1) + 1;
  85.   /* Make a pointer to where consecutive chars leave off,
  86.      going backwards from point.  */
  87.   if (point == BEGV)
  88.     stop = ptr;
  89.   else if (point <= GPT || BEGV > GPT)
  90.     stop = BEGV_ADDR;
  91.   else
  92.     stop = GAP_END_ADDR;
  93.  
  94.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  95.  
  96.   col = 0, tab_seen = 0, post_tab = 0;
  97.   cp = SELECTED_CHAR_TABLE;
  98.  
  99.   while (1)
  100.     {
  101.       if (ptr == stop)
  102.     {
  103.       /* We stopped either for the beginning of the buffer
  104.          or for the gap.  */
  105.       if (ptr == BEGV_ADDR)
  106.         break;
  107.       /* It was the gap.  Jump back over it.  */
  108.       stop = BEGV_ADDR;
  109.       ptr = GPT_ADDR;
  110.       /* Check whether that brings us to beginning of buffer.  */
  111.       if (BEGV >= GPT) break;
  112.     }
  113.  
  114.       c = *--ptr;
  115.       if (c == NEWLINE)
  116.     break;
  117.       else if (c == cp->ct_invisc && EQ (current_buffer->selective_display, Qt))
  118.     break;
  119.       else if (c == HTAB)
  120.     {
  121.       if (tab_seen)
  122.         col = ((col + tab_width) / tab_width) * tab_width;
  123.  
  124.       post_tab += col;
  125.       col = 0;
  126.       tab_seen = 1;
  127.     }
  128.       else
  129.       col += ROPE_LEN (c, cp);
  130.     }
  131.  
  132.   if (tab_seen)
  133.     {
  134.       col = ((col + tab_width) / tab_width) * tab_width;
  135.       col += post_tab;
  136.     }
  137.  
  138.   last_known_column = col;
  139.   last_known_column_point = point;
  140.   last_known_column_modified = MODIFF;
  141.  
  142.   return col;
  143. }
  144.  
  145. ToCol (col)
  146.      int col;
  147. {
  148.   register int fromcol = current_column ();
  149.   register int n;
  150.   register int tab_width = XINT (current_buffer->tab_width);
  151.  
  152.   if (fromcol > col)
  153.     return;
  154.  
  155.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  156.  
  157.   if (indent_tabs_mode)
  158.     {
  159.       n = col / tab_width - fromcol / tab_width;
  160.       if (n)
  161.     {
  162.       while (n-- > 0)
  163.         insert ("\t", 1);
  164.  
  165.       fromcol = (col / tab_width) * tab_width;
  166.     }
  167.     }
  168.  
  169.   while (fromcol < col)
  170.     {
  171.       insert ("        ", min (8, col - fromcol));
  172.       fromcol += min (8, col - fromcol);
  173.     }
  174.  
  175.   last_known_column = col;
  176.   last_known_column_point = point;
  177.   last_known_column_modified = MODIFF;
  178. }
  179.  
  180. DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
  181.   "Indent from point with tabs and spaces until COLUMN is reached.\n\
  182. Always do at least MIN spaces even if that goes past COLUMN;\n\
  183. by default, MIN is zero.")
  184.   (col, minimum)
  185.      Lisp_Object col, minimum;
  186. {
  187.   int mincol;
  188.   register int fromcol;
  189.   register int tab_width = XINT (current_buffer->tab_width);
  190.  
  191.   CHECK_NUMBER (col, 0);
  192.   if (NULL (minimum))
  193.     XFASTINT (minimum) = 0;
  194.   CHECK_NUMBER (minimum, 1);
  195.  
  196.   fromcol = current_column ();
  197.   mincol = fromcol + XINT (minimum);
  198.   if (mincol < XINT (col)) mincol = XINT (col);
  199.  
  200.   if (fromcol == mincol)
  201.     return make_number (fromcol);
  202.  
  203.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  204.  
  205.   if (indent_tabs_mode)
  206.     {
  207.       Lisp_Object n;
  208.       XFASTINT (n) = mincol / tab_width - fromcol / tab_width;
  209.       if (XFASTINT (n) != 0)
  210.     {
  211.       Finsert_char (make_number ('\t'), n);
  212.  
  213.       fromcol = (mincol / tab_width) * tab_width;
  214.     }
  215.     }
  216.  
  217.   XFASTINT (col) = mincol - fromcol;
  218.   Finsert_char (make_number (' '), col);
  219.  
  220.   last_known_column = mincol;
  221.   last_known_column_point = point;
  222.   last_known_column_modified = MODIFF;
  223.  
  224.   XSETINT (col, mincol);
  225.   return col;
  226. }
  227.  
  228. DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
  229.   0, 0, 0,
  230.   "Return the indentation of the current line.\n\
  231. This is the horizontal position of the character\n\
  232. following any initial whitespace.")
  233.   ()
  234. {
  235.   Lisp_Object val;
  236.  
  237.   XFASTINT (val) = position_indentation (find_next_newline (point, -1));
  238.   return val;
  239. }
  240.  
  241. position_indentation (pos)
  242.      register int pos;
  243. {
  244.   register int column = 0;
  245.   register int tab_width = XINT (current_buffer->tab_width);
  246.   register char_t *p;
  247.   register char_t *stop;
  248.  
  249.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  250.  
  251.   stop = &FETCH_CHAR (BufferSafeCeiling (pos)) + 1;
  252.   p = &FETCH_CHAR (pos);
  253.   while (1)
  254.     {
  255.       while (p == stop)
  256.     {
  257.       if (pos == ZV)
  258.         return column;
  259.       pos += p - &FETCH_CHAR (pos);
  260.       p = &FETCH_CHAR (pos);
  261.       stop = &FETCH_CHAR (BufferSafeCeiling (pos)) + 1;
  262.     }
  263.       switch (*p++)
  264.     {
  265.     case SPACE:
  266.       column++;
  267.       break;
  268.     case HTAB:
  269.       column += tab_width - column % tab_width;
  270.       break;
  271.     default:
  272.       return column;
  273.     }
  274.     }
  275. }
  276.  
  277. DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 1, 0,
  278.   "Move point to column COLUMN in the current line.\n\
  279. COLUMN is calculated by adding together the widths of all the displayed\n\
  280. representations of the character between the start of the previous line\n\
  281. and point.  Ignores finite width of screen, which means that\n\
  282. this function may be passed values greater than (screen-width)")
  283.   (column)
  284.      Lisp_Object column;
  285. {
  286.   register int pos = point;
  287.   register int col = current_column ();
  288.   register int goal;
  289.   register int end = ZV;
  290.   register int tab_width = XINT (current_buffer->tab_width);
  291.   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  292.  
  293.   Lisp_Object val;
  294.  
  295.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  296.   CHECK_NUMBER (column, 0);
  297.   goal = XINT (column);
  298.   if (col > goal)
  299.     {
  300.       pos = find_next_newline (pos, -1);
  301.       col = 0;
  302.     }
  303.  
  304.   while (col < goal && pos < end)
  305.     {
  306.       int c = FETCH_CHAR (pos);
  307.       if (c == NEWLINE)
  308.     break;
  309.       if (c == cp->ct_invisc && EQ (current_buffer->selective_display, Qt))
  310.     break;
  311.       pos++;
  312.       /* col++;        BUG! 1991-11-25  Bellman */
  313.       if (c == HTAB)
  314.     {
  315.       col += tab_width - 1;
  316.       col = col / tab_width * tab_width;
  317.     }
  318.       else
  319.      col += ROPE_LEN (c, cp);
  320.     }
  321.  
  322.   SET_PT (pos);
  323.  
  324.   last_known_column = col;
  325.   last_known_column_point = point;
  326.   last_known_column_modified = MODIFF;
  327.  
  328.   XFASTINT (val) = col;
  329.   return val;
  330. }
  331.  
  332. struct position val_compute_motion;
  333.  
  334. struct position *
  335. compute_motion (from, fromvpos, fromhpos, to, tovpos, tohpos, width, hscroll, tab_offset)
  336.      int from, fromvpos, fromhpos, to, tovpos, tohpos;
  337.      register int width;
  338.      int hscroll, tab_offset;
  339. {
  340. /* Note that `cpos' is CURRENT_VPOS << SHORTBITS + CURRENT_HPOS,
  341.    and that CURRENT_HPOS may be negative.  Use these macros
  342.    to extract the hpos or the vpos from cpos or anything like it.
  343.  */
  344. #ifndef SHORT_CAST_BUG
  345. #define HPOS(VAR) (short) (VAR)
  346. #else
  347. #define HPOS(VAR) (((VAR) & (1 << (SHORTBITS - 1)) \
  348.             ? ~((1 << SHORTBITS) - 1) : 0) \
  349.            | (VAR) & ((1 << SHORTBITS) - 1))
  350. /* #define HPOS(VAR) (((VAR) & 0x8000 ? 0xffff0000 : 0) | ((VAR) & 0xffff)) */
  351. #endif /* SHORT_CAST_BUG */
  352.  
  353. #define VPOS(VAR) (((VAR) >> SHORTBITS) + (HPOS (VAR) < 0))
  354.  
  355.  
  356. #ifndef TAHOE_REGISTER_BUG
  357.   register
  358. #endif /* TAHOE_REGISTER_BUG */
  359.     int cpos = fromhpos + (fromvpos << SHORTBITS);
  360.   register int target = tohpos + (tovpos << SHORTBITS);
  361.   register int pos;
  362.   register char_t c;
  363.   register int tab_width = XFASTINT (current_buffer->tab_width);
  364.   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  365.   int selective
  366.     = XTYPE (current_buffer->selective_display) == Lisp_Int
  367.       ? XINT (current_buffer->selective_display)
  368.     : !NULL (current_buffer->selective_display) ? -1 : 0;
  369.   int prevpos;
  370.  
  371.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  372.   for (pos = from; pos < to && cpos < target; pos++)
  373.     {
  374.       prevpos = cpos;
  375.       c = FETCH_CHAR (pos);
  376.       if (c == HTAB)
  377.     {
  378.       cpos += tab_width
  379.         - HPOS (cpos + tab_offset + hscroll - (hscroll > 0)
  380.             /* Add tab_width here to make sure positive.
  381.                cpos can be negative after continuation
  382.                but can't be less than -tab_width.  */
  383.             + tab_width)
  384.           % tab_width;
  385.     }
  386.       else if (c == NEWLINE)
  387.     {
  388.       if (selective > 0 && position_indentation (pos + 1) >= selective)
  389.         {
  390.           /* Skip any number of invisible lines all at once */
  391.           do
  392.         {
  393.           while (++pos < to && FETCH_CHAR(pos) != NEWLINE);
  394.         }
  395.           while (selective > 0 && position_indentation (pos + 1) >= selective);
  396.           pos--;
  397.           cpos += cp->ct_invisr.r_len;
  398.           if (HPOS (cpos) >= width)
  399.         cpos -= HPOS (cpos) - width;
  400.         }
  401.       else
  402.         cpos += (1 << SHORTBITS) - HPOS (cpos);
  403.       cpos -= hscroll;
  404.       if (hscroll > 0) cpos++; /* Count the ! on column 0 */
  405.       tab_offset = 0;
  406.     }
  407.       else if (c == cp->ct_invisc && selective < 0)
  408.     {
  409.       /* In selective display mode,
  410.          everything from a ^M to the end of the line is invisible */
  411.       while (pos < to && FETCH_CHAR(pos) != NEWLINE) pos++;
  412.       pos--;
  413.        cpos += cp->ct_invisr.r_len;
  414.        if (HPOS (cpos) >= width)
  415.          cpos -= HPOS (cpos) - width;
  416.     }
  417.       else
  418.      cpos += ROPE_LEN (c, cp);
  419.  
  420.       if (HPOS (cpos) >= width
  421.       && (HPOS (cpos) > width
  422.           || (pos < ZV - 1
  423.           && FETCH_CHAR (pos + 1) != NEWLINE)))
  424.     {
  425.       if (cpos >= target)
  426.         break;
  427.       if (hscroll
  428.           || (truncate_partial_width_windows
  429.           && width + 1 < screen_width)
  430.           || !NULL (current_buffer->truncate_lines))
  431.         {
  432.           while (pos < to && FETCH_CHAR(pos) != NEWLINE) pos++;
  433.           pos--;
  434.         }
  435.       else
  436.         {
  437.           cpos += (1 << SHORTBITS) - width;
  438.           tab_offset += width;
  439.         }
  440.  
  441.     }
  442.     }
  443.  
  444.   val_compute_motion.bufpos = pos;
  445.   val_compute_motion.hpos = HPOS (cpos);
  446.   val_compute_motion.vpos = VPOS (cpos);
  447.   val_compute_motion.prevhpos = HPOS (prevpos);
  448.  
  449.   /* Nonzero if have just continued a line */
  450.   val_compute_motion.contin
  451.     = pos != from
  452.       && (val_compute_motion.vpos != VPOS (prevpos))
  453.       && c != NEWLINE;
  454.  
  455.   return &val_compute_motion;
  456. }
  457. #undef HPOS
  458. #undef VPOS
  459.  
  460.  
  461. pos_tab_offset (w, pos)
  462.      struct window *w;
  463.      register int pos;
  464. {
  465.   int opoint = point;
  466.   int col;
  467.  
  468.   if (pos == BEGV || FETCH_CHAR (pos - 1) == NEWLINE)
  469.     return 0;
  470.   SET_PT (pos);
  471.   col = current_column ();
  472.   SET_PT (opoint);
  473.   return col - (col % (XFASTINT (w->width) - 1));
  474. }
  475.  
  476. /* start_hpos is the hpos of the first character of the buffer:
  477.    zero except for the minibuffer window,
  478.    where it is the width of the prompt.  */
  479.  
  480. struct position val_vmotion;
  481.  
  482. struct position *
  483. vmotion (from, vtarget, width, hscroll, window)
  484.      register int from, vtarget, width;
  485.      int hscroll;
  486.      Lisp_Object window;
  487. {
  488.   struct position pos;
  489.   /* vpos is cumulative vertical position, changed as from is changed */
  490.   register int vpos = 0;
  491.   register int prevline;
  492.   register int first;
  493.   int lmargin = hscroll > 0 ? 1 - hscroll : 0;
  494.   int selective
  495.     = XTYPE (current_buffer->selective_display) == Lisp_Int
  496.       ? XINT (current_buffer->selective_display)
  497.     : !NULL (current_buffer->selective_display) ? -1 : 0;
  498.   int start_hpos = (EQ (window, minibuf_window) ? minibuf_prompt_width : 0);
  499.  
  500.  retry:
  501.   if (vtarget > vpos)
  502.     {
  503.       /* Moving downward is simple, but must calculate from beg of line 
  504.      to determine hpos of starting point */
  505.       if (from > BEGV && FETCH_CHAR (from - 1) != NEWLINE)
  506.     {
  507.       prevline = find_next_newline (from, -1);
  508.       while (selective > 0
  509.          && prevline > BEGV
  510.          && position_indentation (prevline) >= selective)
  511.         prevline = find_next_newline (prevline - 1, -1);
  512.       pos = *compute_motion (prevline, 0,
  513.                  lmargin + (prevline == 1 ? start_hpos : 0),
  514.                  from, 10000, 10000,
  515.                  width, hscroll, 0);
  516.     }
  517.       else
  518.     {
  519.       pos.hpos = lmargin + (from == 1 ? start_hpos : 0);
  520.       pos.vpos = 0;
  521.     }
  522.       return compute_motion (from, vpos, pos.hpos,
  523.                  ZV, vtarget, - (1 << (SHORTBITS - 1)),
  524.                  width, hscroll, pos.vpos * width);
  525.     }
  526.  
  527.   /* To move upward, go a line at a time until
  528.      we have gone at least far enough */
  529.  
  530.   first = 1;
  531.  
  532.   while ((vpos > vtarget || first) && from > BEGV)
  533.     {
  534.       prevline = from;
  535.       while (1)
  536.     {
  537.       prevline = find_next_newline (prevline - 1, -1);
  538.       if (prevline == BEGV
  539.           || selective <= 0
  540.           || position_indentation (prevline) < selective)
  541.         break;
  542.     }
  543.       pos = *compute_motion (prevline, 0,
  544.                  lmargin + (prevline == 1 ? start_hpos : 0),
  545.                  from, 10000, 10000,
  546.                  width, hscroll, 0);
  547.       vpos -= pos.vpos;
  548.       first = 0;
  549.       from = prevline;
  550.     }
  551.  
  552.   /* If we made exactly the desired vertical distance,
  553.      or if we hit beginning of buffer,
  554.      return point found */
  555.   if (vpos >= vtarget)
  556.     {
  557.       val_vmotion.bufpos = from;
  558.       val_vmotion.vpos = vpos;
  559.       val_vmotion.hpos = lmargin;
  560.       val_vmotion.contin = 0;
  561.       val_vmotion.prevhpos = 0;
  562.       return &val_vmotion;
  563.     }
  564.   
  565.   /* Otherwise find the correct spot by moving down */
  566.   goto retry;
  567. }
  568.  
  569. DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 1, 0,
  570.   "Move to start of screen line LINES lines down.\n\
  571. If LINES is negative, this is moving up.\n\
  572. Sets point to position found; this may be start of line\n\
  573.  or just the start of a continuation line.\n\
  574. Returns number of lines moved; may be closer to zero than LINES\n\
  575.  if beginning or end of buffer was reached.")
  576.   (lines)
  577.      Lisp_Object lines;
  578. {
  579.   struct position pos;
  580.   register struct window *w = XWINDOW (selected_window);
  581.  
  582.   CHECK_NUMBER (lines, 0);
  583.  
  584.   pos = *vmotion (point, XINT (lines),
  585.           XFASTINT (w->width) - 1
  586.           - (XFASTINT (w->width) + XFASTINT (w->left)
  587.              != XFASTINT (XWINDOW (minibuf_window)->width)),
  588.           /* Not XFASTINT since perhaps could be negative */
  589.           XINT (w->hscroll), selected_window);
  590.  
  591.   SET_PT (pos.bufpos);
  592.   return make_number (pos.vpos);
  593. }
  594.  
  595. syms_of_indent ()
  596. {
  597.   DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode,
  598.     "*Indentation can insert tabs if this is non-nil.\n\
  599. Setting this variable automatically makes it local to the current buffer.");
  600.   indent_tabs_mode = 1;
  601.  
  602.   defsubr (&Scurrent_indentation);
  603.   defsubr (&Sindent_to);
  604.   defsubr (&Scurrent_column);
  605.   defsubr (&Smove_to_column);
  606.   defsubr (&Svertical_motion);
  607. }
  608.